

/**
     * Coze聊天助手应用
     * 提供智能对话、会话管理等功能
     */
    (function () {
        // ===== 配置参数 =====
        const CONFIG = {
            API: {
                WORKFLOW_ID: "7486679564925829161", // 替换为您的Workflow ID
                SERVER_API: {
                    SERVER_URL: window.location.origin,
                    TOKEN_ENDPOINT: window.location.origin + '/api/token',
                    CHAT_ENDPOINT: window.location.origin + '/api/chat'
                },
                TIMEOUT: 30000
            },
            STORAGE: {
                CONVERSATION_LIST: "coze_conversation_list",
                CONVERSATION_PREFIX: "coze_chat_",
                MAX_CONVERSATIONS: 10
            },
            UI: {
                WELCOME_MESSAGE: "您好，我是艾美思普智能助手，有什么可以帮您？",
                THINKING_MESSAGE: "正在思考...",
                ERROR_MESSAGE: "抱歉，发生了错误: "
            }
        };

        // ===== 状态管理 =====
        const STATE = {
            conversationHistory: [],
            currentConversationId: null,  // 本地会话ID
            conversations: [],
            cozeConversationId: null      // Coze API会话ID
        };

        // ===== DOM元素 =====
        const DOM = {
            chatMessages: document.getElementById('chatMessages'),
            messageInput: document.getElementById('messageInput'),
            sendButton: document.getElementById('sendButton'),
            newConversationBtn: document.getElementById('newConversationBtn'),
            conversationSelector: document.getElementById('conversationSelector'),
            apiStatus: document.getElementById('apiStatus')
        };

        // ===== 工具函数 =====
        const Utils = {
            /**
             * 生成唯一ID
             * @param {string} prefix - ID前缀
             * @returns {string} 唯一ID
             */
            generateId: function (prefix = 'id') {
                return `${prefix}_${Date.now()}_${Math.floor(Math.random() * 1000)}`;
            },

            /**
             * 格式化日期时间
             * @param {Date|number} date - 日期对象或时间戳
             * @param {boolean} includeTime - 是否包含时间
             * @returns {string} 格式化后的日期时间
             */
            formatDate: function (date, includeTime = true) {
                const d = new Date(date);
                const year = d.getFullYear();
                const month = String(d.getMonth() + 1).padStart(2, '0');
                const day = String(d.getDate()).padStart(2, '0');

                if (!includeTime) {
                    return `${year}-${month}-${day}`;
                }

                const hours = String(d.getHours()).padStart(2, '0');
                const minutes = String(d.getMinutes()).padStart(2, '0');
                return `${year}-${month}-${day} ${hours}:${minutes}`;
            },

            /**
             * 安全的JSON解析
             * @param {string} str - 要解析的JSON字符串
             * @param {*} defaultValue - 解析失败时的默认值
             * @returns {*} 解析结果或默认值
             */
            safeJSONParse: function (str, defaultValue = null) {
                try {
                    return JSON.parse(str);
                } catch (e) {
                    console.error('JSON解析失败:', e);
                    return defaultValue;
                }
            }
        };

        // ===== API模块 =====
        const API = {
            /**
             * 检查API连接状态
             * @returns {Promise<boolean>} 连接是否正常
             */
            checkConnection: async function () {
                try {
                    const response = await fetch(CONFIG.API.SERVER_API.TOKEN_ENDPOINT, {
                        method: 'POST',
                        headers: {
                            'Content-Type': 'application/json'
                        },
                        body: JSON.stringify({
                            sessionName: STATE.currentConversationId || 'default'
                        })
                    });
                    return response.ok;
                } catch (error) {
                    console.error('API连接检查失败:', error);
                    return false;
                }
            },

            /**
             * 更新API状态指示器
             * @param {boolean} isConnected - 是否连接正常
             */
            updateStatusIndicator: function (isConnected) {
                const indicator = DOM.apiStatus.querySelector('.status-indicator');
                if (isConnected) {
                    indicator.className = 'status-indicator status-online';
                    DOM.apiStatus.title = 'API连接正常';
                } else {
                    indicator.className = 'status-indicator status-error';
                    DOM.apiStatus.title = 'API连接异常';
                }
            },

            /**
             * 创建新的Coze会话
             * @returns {Promise<string>} 新创建的会话ID
             */
            createNewCozeConversation: async function() {
                try {
                    // 构建请求数据
                    const requestData = {
                        session_id: STATE.currentConversationId,
                        workflow_id: CONFIG.API.WORKFLOW_ID
                    };

                    console.log('请求创建新的Coze会话:', requestData);

                    // 发送请求到新的创建会话API端点
                    const response = await fetch('/api/conversation/create', {
                        method: 'POST',
                        headers: {
                            'Content-Type': 'application/json'
                        },
                        body: JSON.stringify(requestData)
                    });

                    if (!response.ok) {
                        const errorText = await response.text();
                        console.error('创建Coze会话失败:', errorText);
                        throw new Error(`创建会话失败: ${response.status} ${response.statusText}`);
                    }

                    const data = await response.json();
                    console.log('成功创建Coze会话:', data);
                    
                    if (data.conversation_id) {
                        return data.conversation_id;
                    } else {
                        throw new Error('服务器未返回有效的会话ID');
                    }
                } catch (error) {
                    console.error('创建Coze会话出错:', error);
                    throw error;
                }
            },

            /**
             * 发送消息到API
             * @param {string} userInput - 用户输入
             * @returns {Promise<string>} 机器人回复
             */
            sendMessage: async function (userInput) {
                try {
                    // 获取当前会话的历史消息
                    const conversation = STATE.conversations.find(c => c.id === STATE.currentConversationId);
                    if (!conversation) {
                        throw new Error('找不到当前会话');
                    }
                    
                    // 构建历史消息数组，最多包含最近10条消息
                    const historyMessages = conversation.messages
                        .slice(-10)  // 只取最近10条消息
                        .map(msg => ({
                            role: msg.role === 'bot' ? 'assistant' : msg.role,
                            content: msg.content
                        }));
                        
                    // 添加当前用户消息
                    const allMessages = [
                        ...historyMessages,
                        {
                            role: "user",
                            content: userInput
                        }
                    ];

                    // 构建请求数据
                    const requestData = {
                        messages: allMessages,
                        workflow_id: CONFIG.API.WORKFLOW_ID,
                        session_id: STATE.currentConversationId,
                        conversation_id: STATE.cozeConversationId // 传递Coze会话ID
                    };

                    console.log('发送请求到服务器:', requestData);

                    // 设置请求超时
                    const controller = new AbortController();
                    const timeoutId = setTimeout(() => controller.abort(), CONFIG.API.TIMEOUT);

                    // 发送请求
                    const response = await fetch(CONFIG.API.SERVER_API.CHAT_ENDPOINT, {
                        method: 'POST',
                        headers: {
                            'Content-Type': 'application/json'
                        },
                        body: JSON.stringify(requestData),
                        signal: controller.signal
                    });

                    clearTimeout(timeoutId);

                    if (!response.ok) {
                        const errorText = await response.text();
                        console.error('API错误响应:', errorText);
                        throw new Error(`API调用失败: ${response.status} ${response.statusText}`);
                    }

                    const data = await response.json();
                    console.log('收到服务器响应:', data);
                    
                    // 保存Coze会话ID以便后续使用
                    if (data.conversation_id) {
                        STATE.cozeConversationId = data.conversation_id;
                        
                        // 同时更新当前会话对象中的Coze会话ID
                        conversation.cozeConversationId = data.conversation_id;
                        ConversationManager.saveConversationList();
                        
                        console.log('已保存Coze会话ID:', data.conversation_id);
                    }

                    return data.content || '抱歉，我没有得到有效回复';
                } catch (error) {
                    console.error('API调用出错:', error);
                    if (error.name === 'AbortError') {
                        throw new Error('请求超时，请稍后再试');
                    }
                    throw error;
                }
            }
        };

        // ===== 会话管理模块 =====
        const ConversationManager = {
            /**
             * 初始化会话管理
             */
            init: function () {
                this.loadConversationList();

                // 新建会话按钮事件
                DOM.newConversationBtn.addEventListener('click', () => this.createNewConversation());

                // 会话选择器事件
                DOM.conversationSelector.addEventListener('change', function () {
                    const selectedId = this.value;
                    if (selectedId) {
                        ConversationManager.switchConversation(selectedId);
                    }
                });

                // 如果没有当前会话，创建一个新会话
                if (!STATE.currentConversationId) {
                    this.createNewConversation();
                }

                // 定期检查API状态
                this.checkAPIStatus();
                setInterval(() => this.checkAPIStatus(), 60000); // 每分钟检查一次
            },

            /**
             * 检查API状态
             */
            checkAPIStatus: async function () {
                const isConnected = await API.checkConnection();
                API.updateStatusIndicator(isConnected);
            },

            /**
             * 加载会话列表
             */
            loadConversationList: function () {
                try {
                    // 从本地存储获取会话列表
                    const savedList = localStorage.getItem(CONFIG.STORAGE.CONVERSATION_LIST);
                    if (savedList) {
                        STATE.conversations = Utils.safeJSONParse(savedList, []);

                        // 更新会话选择器
                        this.updateConversationSelector();

                        console.log('已加载会话列表:', STATE.conversations.length, '个会话');
                    }
                } catch (error) {
                    console.error('加载会话列表失败:', error);
                    STATE.conversations = [];
                }
            },

            /**
             * 更新会话选择器
             */
            updateConversationSelector: function () {
                // 清空选择器
                while (DOM.conversationSelector.options.length > 1) {
                    DOM.conversationSelector.remove(1);
                }

                // 添加会话选项
                STATE.conversations.forEach(conv => {
                    const option = document.createElement('option');
                    option.value = conv.id;

                    // 创建会话标题：使用第一条消息或默认标题
                    let title = '新会话';
                    if (conv.messages && conv.messages.length > 0) {
                        const firstUserMsg = conv.messages.find(m => m.role === 'user');
                        if (firstUserMsg) {
                            // 使用用户的第一条消息作为标题（最多20个字符）
                            title = firstUserMsg.content.substring(0, 20);
                            if (firstUserMsg.content.length > 20) {
                                title += '...';
                            }
                        }
                    }

                    // 添加日期信息
                    const dateStr = Utils.formatDate(conv.timestamp, false);
                    const timeStr = new Date(conv.timestamp).toLocaleTimeString('zh-CN', { hour: '2-digit', minute: '2-digit' });

                    option.text = `${dateStr} ${timeStr} - ${title}`;

                    // 如果是当前会话，设为选中
                    if (conv.id === STATE.currentConversationId) {
                        option.selected = true;
                    }

                    DOM.conversationSelector.appendChild(option);
                });
            },

            /**
             * 保存会话列表
             */
            saveConversationList: function () {
                try {
                    localStorage.setItem(CONFIG.STORAGE.CONVERSATION_LIST, JSON.stringify(STATE.conversations));
                } catch (error) {
                    console.error('保存会话列表失败:', error);
                }
            },

            

            /**
             * 创建新会话
             */
            createNewConversation: async function () {
                try {
                    // 生成新的本地会话ID
                    const newId = Utils.generateId('conv');

                    // 创建会话对象
                    const newConversation = {
                        id: newId,
                        timestamp: Date.now(),
                        messages: [],
                        cozeConversationId: null  // 初始化为null，稍后会更新
                    };

                    // 添加到会话列表
                    STATE.conversations.unshift(newConversation);

                    // 限制会话数量
                    if (STATE.conversations.length > CONFIG.STORAGE.MAX_CONVERSATIONS) {
                        STATE.conversations = STATE.conversations.slice(0, CONFIG.STORAGE.MAX_CONVERSATIONS);
                    }

                    // 保存会话列表
                    this.saveConversationList();

                    // 切换到新会话
                    this.switchConversation(newId);

                    // 更新会话选择器
                    this.updateConversationSelector();

                    console.log('已创建本地会话:', newId);

                    // 添加欢迎消息
                    UI.addMessage(CONFIG.UI.WELCOME_MESSAGE, 'bot');
                    
                    // 立即创建Coze会话ID
                    UI.showLoading('正在初始化会话...');
                    
                    try {
                        const cozeConversationId = await API.createNewCozeConversation();
                        
                        // 更新会话对象和全局状态
                        STATE.cozeConversationId = cozeConversationId;
                        newConversation.cozeConversationId = cozeConversationId;
                        this.saveConversationList();
                        
                        console.log('已关联Coze会话ID:', cozeConversationId);
                    } catch (error) {
                        console.error('创建Coze会话失败，将在首次发送消息时自动创建:', error);
                    } finally {
                        UI.hideLoading();
                    }
                    
                } catch (error) {
                    console.error('创建新会话失败:', error);
                    UI.showError('创建新会话失败: ' + error.message);
                }
            },

            /**
             * 切换会话
             * @param {string} conversationId - 本地会话ID
             */
            switchConversation: function (conversationId) {
                // 查找会话
                const conversation = STATE.conversations.find(c => c.id === conversationId);
                if (!conversation) {
                    console.error('找不到会话:', conversationId);
                    return;
                }

                // 更新当前会话ID
                STATE.currentConversationId = conversationId;
                
                // 恢复该会话的Coze会话ID
                STATE.cozeConversationId = conversation.cozeConversationId;
                console.log('恢复Coze会话ID:', STATE.cozeConversationId);

                // 加载会话消息
                this.loadConversationMessages(conversation);

                // 更新会话选择器
                DOM.conversationSelector.value = conversationId;

                console.log('已切换到会话:', conversationId);
            },

            /**
             * 加载会话消息
             * @param {Object} conversation - 会话对象
             */
            loadConversationMessages: function (conversation) {
                // 清空消息区域
                DOM.chatMessages.innerHTML = '';

                // 加载消息历史
                if (conversation.messages && conversation.messages.length > 0) {
                    conversation.messages.forEach(msg => {
                        UI.addMessage(msg.content, msg.role);
                    });
                } else {
                    // 如果没有消息，添加欢迎消息
                    UI.addMessage(CONFIG.UI.WELCOME_MESSAGE, 'bot');
                }

                // 滚动到底部
                UI.scrollToBottom();
            },

            /**
             * 添加消息到当前会话
             * @param {string} content - 消息内容
             * @param {string} role - 消息角色(user/bot)
             */
            addMessageToConversation: function (content, role) {
                // 查找当前会话
                const conversation = STATE.conversations.find(c => c.id === STATE.currentConversationId);
                if (!conversation) {
                    console.error('找不到当前会话');
                    return;
                }

                // 添加消息
                conversation.messages.push({
                    id: Utils.generateId('msg'),
                    content: content,
                    role: role,
                    timestamp: Date.now()
                });

                // 保存会话列表
                this.saveConversationList();

                // 如果是第一条用户消息，更新会话选择器（因为标题可能变化）
                if (role === 'user' && conversation.messages.filter(m => m.role === 'user').length === 1) {
                    this.updateConversationSelector();
                }
            }
        };

        // ===== UI模块 =====
        const UI = {
            /**
             * 初始化UI
             */
            init: function () {
                // 发送按钮事件
                DOM.sendButton.addEventListener('click', () => this.handleSendMessage());

                // 输入框回车事件
                DOM.messageInput.addEventListener('keypress', (e) => {
                    if (e.key === 'Enter') {
                        e.preventDefault();
                        this.handleSendMessage();
                    }
                });
                
                // 初始化表单处理模块
                if (typeof FormHandler !== 'undefined') {
                    FormHandler.init({
                        container: document.getElementById('formContainer'),
                        iframe: document.getElementById('leaveForm'),
                        iframeSrc: 'http://192.168.110.16:8080/main/renshi/kaoqing/qingjia'
                    });
                    
                    // 添加表单切换按钮事件
                    const toggleFormBtn = document.getElementById('toggleFormBtn');
                    if (toggleFormBtn) {
                        toggleFormBtn.addEventListener('click', function() {
                            FormHandler.toggleForm();
                        });
                    }
                }
            },

            /**
             * 处理发送消息
             */
            handleSendMessage: async function () {
                const userInput = DOM.messageInput.value.trim();

                // 检查是否为空
                if (!userInput) {
                    return;
                }

                // 清空输入框
                DOM.messageInput.value = '';

                // 添加用户消息到UI
                this.addMessage(userInput, 'user');

                // 添加用户消息到会话
                ConversationManager.addMessageToConversation(userInput, 'user');

                // 添加思考中消息
                const thinkingMsgElement = this.addMessage(CONFIG.UI.THINKING_MESSAGE, 'bot');

                try {
                    // 发送消息到API
                    const botResponse = await API.sendMessage(userInput);

                    // 移除思考中消息
                    DOM.chatMessages.removeChild(thinkingMsgElement);

                    // 添加机器人回复
                    this.addMessage(botResponse, 'bot');

                    // 添加机器人回复到会话
                    ConversationManager.addMessageToConversation(botResponse, 'bot');

                } catch (error) {
                    // 移除思考中消息
                    DOM.chatMessages.removeChild(thinkingMsgElement);

                    // 显示错误消息
                    this.showError(CONFIG.UI.ERROR_MESSAGE + error.message);
                    console.error('发送消息失败:', error);
                }
            },

            /**
             * 添加消息到UI
             * @param {string} content - 消息内容
             * @param {string} role - 消息角色(user/bot)
             * @returns {HTMLElement} 消息元素
             */
            addMessage: function (content, role) {
                // 创建消息元素
                const messageDiv = document.createElement('div');
                messageDiv.className = `message ${role === 'user' ? 'user-message' : 'bot-message'}`;
                
                // 处理消息内容
                let displayContent = content;
                let hasFormData = false;
                
                // 如果是机器人消息，检查是否包含表单数据
                if (role === 'bot' && typeof FormHandler !== 'undefined') {
                    // 检查是否包含表单数据
                    hasFormData = FormHandler.hasFormData(content);
                    
                    if (hasFormData) {
                        console.log('检测到表单数据，正在处理...');
                        
                        // 处理表单数据
                        FormHandler.processMessage(content);
                        
                        // 移除消息中的表单标记，使显示更干净
                        displayContent = content.replace(/<user-form>[\s\S]*?<\/user-form>/g, '');
                        
                        // // 添加表单操作按钮
                        // setTimeout(() => {
                        //     const formButton = document.createElement('button');
                        //     formButton.textContent = '查看表单';
                        //     formButton.className = 'form-button';
                        //     formButton.addEventListener('click', function() {
                        //         FormHandler.showForm();
                        //     });
                            
                        //     messageDiv.appendChild(document.createElement('br'));
                        //     messageDiv.appendChild(formButton);
                        // }, 100);
                    }
                }
                
                // 设置消息内容
                messageDiv.innerHTML = displayContent;
                
                // 添加到消息区域
                DOM.chatMessages.appendChild(messageDiv);
                
                // 滚动到底部
                this.scrollToBottom();
                
                return messageDiv;
            },

            /**
             * 滚动到底部
             */
            scrollToBottom: function () {
                DOM.chatMessages.scrollTop = DOM.chatMessages.scrollHeight;
            },

            /**
             * 显示加载中提示
             * @param {string} message - 提示消息
             */
            showLoading: function(message) {
                // 检查是否已存在加载提示
                let loadingDiv = document.querySelector('.loading-message');
                if (!loadingDiv) {
                    loadingDiv = document.createElement('div');
                    loadingDiv.className = 'loading-message';
                    loadingDiv.style.cssText = 'background-color: #e8f5e9; padding: 10px; border-radius: 4px; margin: 10px 0; text-align: center; color: #2e7d32;';
                    DOM.chatMessages.appendChild(loadingDiv);
                }
                
                loadingDiv.textContent = message || '加载中...';
                this.scrollToBottom();
                return loadingDiv;
            },
            
            /**
             * 隐藏加载中提示
             */
            hideLoading: function() {
                const loadingDiv = document.querySelector('.loading-message');
                if (loadingDiv) {
                    DOM.chatMessages.removeChild(loadingDiv);
                }
            },

            /**
             * 显示错误消息
             * @param {string} message - 错误消息
             */
            showError: function (message) {
                const errorDiv = document.createElement('div');
                errorDiv.className = 'error-message';
                errorDiv.textContent = message;

                DOM.chatMessages.appendChild(errorDiv);

                // 滚动到底部
                this.scrollToBottom();

                // 5秒后移除错误消息
                setTimeout(() => {
                    try {
                        DOM.chatMessages.removeChild(errorDiv);
                    } catch (e) {
                        // 忽略可能的错误
                    }
                }, 5000);
            }
        };

        // ===== 应用初始化 =====
        function initApp() {
            // 初始化各模块
            ConversationManager.init();
            UI.init();

     
        // 初始化表单处理模块
        FormHandler.init({
            container: document.getElementById('formContainer'),
            iframe: document.getElementById('leaveForm'),
            iframeSrc: 'http://192.168.110.16:8080/main/renshi/kaoqing/qingjia'
        });
        
        // 添加表单切换按钮事件
        document.getElementById('toggleFormBtn').addEventListener('click', function() {
            FormHandler.toggleForm();
        });
        
        console.log('Coze聊天助手应用已初始化');
    
    
    // 修改 UI.addMessage 方法，添加表单数据处理
    const originalAddMessage = UI.addMessage;
    UI.addMessage = function(content, role) {
        const messageDiv = originalAddMessage.call(this, content, role);
        
        // 如果是机器人消息，检查是否包含表单数据
        if (role === 'bot' && FormHandler.hasFormData(content)) {
            console.log('检测到表单数据，正在处理...');
            
            // 处理表单数据
            const processed = FormHandler.processMessage(content);
            
            if (processed) {
                // 添加表单操作按钮
                const formButton = document.createElement('button');
                formButton.textContent = '查看表单';
                formButton.className = 'form-button';
                formButton.addEventListener('click', function() {
                    FormHandler.showForm();
                });
                
                messageDiv.appendChild(document.createElement('br'));
                messageDiv.appendChild(formButton);
            }
            
            // 移除消息中的表单标记，使显示更干净
            messageDiv.innerHTML = messageDiv.innerHTML.replace(/<user-form>[\s\S]*?<\/user-form>/g, '');
        }
        
        return messageDiv;
    };
        }

        // 启动应用
        initApp();
    })();
